Fő tartalom

Tantárgy/kurzus: A számítógép és az Internet > 1. témakör

4. lecke: A számok tárolásának korlátai

A számábrázolás korlátai, túlcsordulás és kerekítés

Amikor a számítógépes programok számokat tárolnak változókban, a számítógépnek meg kell találnia a szám ábrázolásának módját a számítógép memóriájában. A számítógépek különböző stratégiákat alkalmaznak attól függően, hogy egy szám egész szám-e vagy sem. A számítógépes memória korlátai miatt a programok a számváltozók kerekítésével, túlcsordulásával vagy pontosságával kapcsolatos problémákba ütköznek.

Egész számok ábrázolása

Az egész számok olyan számok, amelyek tört összetevő nélkül írhatóak le. Ugyanazt a kifejezést használják a programozásban és a matematikában is, így remélhetőleg ismerős számodra a kifejezés.

Ezek mind egész számok:

120

10

0

- 20

Hogyan tudja egy programozási nyelv ábrázolni ezeket az egész számokat a számítógép memóriájában? Nos, a számítógépek minden adatot bitekkel fejeznek ki, így tudjuk, hogy végső soron minden egyes szám 0-k és 1-ek sorozatából áll.

Hogy egyszerű példával kezdjük, képzeljünk el egy olyan számítógépet, amely csak 4 bitet használ az egész számok ábrázolására. Az első bitet az egész szám előjelének – amely vagy pozitív vagy negatív –, a további 3 bitet pedig a szám abszolút értéknek a jelölésére használhatja.

Ebben a rendszerben az 1-es szám így ábrázolható:

0	0	0	1
+/-	$4$ ‍	$2$ ‍	$1$ ‍
előjel	$2^{2}$ ‍	$2^{1}$ ‍	$2^{0}$ ‍

Az előjelbitben lévő

0

pozitív számot jelöl, a jobb szélső bitben lévő

1

pedig az érték

2^{0}

(

1

) helyét.

Melyik az a legnagyobb szám, amely ebben a rendszerben ábrázolható? Töltsük fel az összes értékbitet

1

-gyel, és meglátjuk:

0	1	1	1
+/-	$4$ ‍	$2$ ‍	$1$ ‍
előjel	$2^{2}$ ‍	$2^{1}$ ‍	$2^{0}$ ‍

Ez a (pozitív)

7

, mivel

2^{2} + 2^{1} + 2^{0} = (4 + 2 + 1) = 7

Mérd fel tudásodat!

Vegyünk egy számítógépet, amely 6 bitet használ az egész számok ábrázolására: 1 bit az előjelre és 5 bit a tényleges számra. Mekkora a legnagyobb pozitív egész szám, amit ábrázolni tud?

Túlcsordulás

Mi történne, ha egy ilyen programot futtatnánk a 4-bites számítógépen, ahol a legnagyobb pozitív egész szám a 7?

var x = 7;
var y = x + 1;

A számítógép az x változót jól tudja tárolni, de y eggyel nagyobb, mint a legnagyobb egész szám, amelyet a 4 bit segítségével ábrázolni tud. Ilyen esetben a számítógép „túlcsordulási hibát” jelenthet, vagy megjeleníthet például egy olyan üzenetet, hogy „a szám túl nagy”. Az is előfordulhat, hogy a számot lemetszi (az összes eredményt 7-re korlátozza), vagy a számot körbefordítja (így a 8 1-gyé válik).

Nem akarunk ezen helyzetek egyikébe sem kerülni, ezért fontos, hogy ismerjük a nyelvünk és a környezetünk korlátait, amikor programokat írunk.

Mérd fel tudásodat!

Egy olyan számítógépen, amely 6 bitet használ az egész számok ábrázolására (ebből 1 bitet az előjelre), mely műveletek eredményeznek túlcsordulást?

Szerencsére a legtöbb modern számítógép 64-bites architektúrát használ, amely hihetetlenül nagy egész számokat képes tárolni. JavaScriptben a legnagyobb biztonságos egész szám 9 007 199 254 740 991, ami

2^{53} - 1

-nek felel meg. Ezen túl már a veszélyzónában vagyunk.

✏️ Játssz a veszélyzónában! A JavaScript nem jelenít meg túlcsordulási hibákat, de néhány más furcsa dolgot igen.

📝 Hasonló kódokat találsz itt: App Lab | Snap | Python

Lebegőpontos számábrázolás

Láttuk, hogy az egész számok számítógépes tárolásának vannak korlátai. A nem egész számok, például a törtek és az irracionális számok még trükkösebben ábrázolhatók a számítógép memóriájában.

Gondoljunk csak az olyan számokra, mint a

2 / 5

1,234

9,999 999

, vagy a híres, soha véget nem érő

π

A számítógépes nyelvek jellemzően a nem egész számok (és néha az egész számok is) esetében lebegőpontos számábrázolást használnak. Ez hasonlít a „tudományos jelöléshez” (normálalakjához), egy olyan ábrázoláshoz, amelyet korábbi tanulmányaidból már ismerhetsz.

A lebegőpontos ábrázolásban egy számot megszorozunk egy alappal, amelyet egy hatványkitevőre emelünk:

300 = 3 \cdot \underset{alap}{\underset{⏟}{10}}^{\overset{kitevő}{\overset{⏞}{2}}}

Mivel a számítógépek a decimális helyett a bináris számrendszert használják, a lebegőpontos számok alapja

10

helyett

2

. Emiatt a

2

pontos hatványait tartalmazó számokat a legegyszerűbb ábrázolni:

\begin{aligned} 128 = 1 \cdot 2^{7} \\ 256 = 1 \cdot 2^{8} \end{aligned}

A 2 hatványai közötti számok így néznek ki:

\begin{aligned} 160 = 1, 25 \cdot 2^{7} \\ 192 = 1, 50 \cdot 2^{7} \\ 224 = 1, 75 \cdot 2^{7} \end{aligned}

Mi a helyzet a nem egész számokkal? Ismét a

2

hatványait a legegyszerűbb ábrázolni.

\begin{aligned} 0, 50 = 1 \cdot 2^{- 1} \\ 0, 25 = 1 \cdot 2^{- 2} \end{aligned}

A lebegőpontos számjegyek a 2-hatványok közötti törtek ábrázolására is alkalmasak:

\begin{aligned} 0,750 = 1, 5 \cdot 2^{- 1} \\ 0,375 = 1, 5 \cdot 2^{- 2} \end{aligned}

Miután a számítógép meghatározza egy szám lebegőpontos ábrázolását, azt bitekben tárolja. A modern számítógépek 64-bites rendszert használnak, ebből 1 bitet az előjelre, 11 bit a kitevő és 52 bit az előtte lévő szám.

Íme

0,375

ebben a bináris lebegőpontos számábrázolásban:

11 111 111 011 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000

A bitekre történő pontos fordítás bonyolultabb, mint amibe itt bele tudnánk menni, de ez nagyszerű téma azoknak, akik szeretnének mélyebbre ásni.

Kerekítési hibák

A lebegőpontos számábrázolás azonban még mindig nem képes minden számot teljes mértékben megjeleníteni. Nézzük meg az

1 / 3

törtet és annak lebegőpontos számábrázolását:

1 / 3 = 1, \overset{―}{3} \cdot 2^{- 2}

Binárisan a

, \overset{―}{3}

még mindig egy végtelenül ismétlődő sorozat:

101 010 101…

Nem tárolhatunk végtelen sorozatot egy számítógépben! Egy bizonyos ponton a számítógépnek valahogyan be kell fejeznie a számot, vagy levágva, vagy a legközelebbi lebegőpontos számra kerekítve. A számítógépeknek elég gyakran ezt kell tenniük, mivel még az olyan törtek is, mint az

1 / 10

(amely decimálisan mindössze

0, 1

) binárisra való konvertálás után végtelenül ismétlődő sorozatként végződnek.

Gyakran addig nem vesszük észre, hogy egy szám kisebb pontossággal van ábrázolva, amíg nem használjuk őket számításokban. Ekkor tapasztalhatunk kerekítési hibát az eredményekben.

✏️ Íme egy program, amely megpróbálja összeadni a

0, 1 + 0, 1 + 0, 1

-et. A nem számítógépes világban tudjuk, hogy ez

0, 3

. De a számítógép minden egyes

0, 1

értéket kerekített bináris törtként tárol, és amikor összeadja őket, nem egészen azt kapjuk, amit várunk...

📝 Hasonló kódokat itt találsz: App Lab | Snap | Python

Minél több bitet tudunk használni, annál pontosabbak lesznek a számok és a számítások. A modern 64-bites rendszerek elég nagy pontosságot biztosítanak alacsony kockázatú számításokhoz.

Talán egyszer az életed egy pontján olyan programokat írsz majd, amelyek szavazási eredményeket számolnak ki, önvezető autókat hajtanak meg, vagy akár rakétákat indítanak el. Ha nagy a kockázat, a pontosság számít.

🙋🏽🙋🏻‍♀️🙋🏿‍♂️Kérdéseid vannak a témával kapcsolatban? Szívesen válaszolunk – tedd fel őket bátran alább!

Szeretnél részt venni a beszélgetésben?

Jelentkezz be

Rendezés:

Még nincs hozzászólás.

Tudsz angolul? Kattints ide, ha meg szeretnéd nézni, milyen beszélgetések folynak a Khan Academy angol nyelvű oldalán.