Főoldal ] Számítástechnika ] Matek, fizika, érdekességek ] Kötelező olvasmányok ]

Hogyan számol a számítógépünk?

Ismeretes, hogy a számítógép kettes (bináris) számrendszert használ, és abban dolgozik. De azt nem nagyon tudjuk, hogy hogyan csinálja, ha kíváncsiak vagyunk rá, akkor olvassuk tovább az oldalt.

Először is ahhoz, hogy mi is tudjunk számolni kettes számrendszerben, és le tudjuk ellenőrizni, hogy hogyan működik ez az egész, kell egy kis említést tenni attól, hogy hogyan lehet a tízes számrendszerből kettesbe és visszafelé számokat átváltani.

Egész számok átváltása tízesből kettes számrendszerbe

Erre találták ki az oszlopos módszert.

Váltsuk át a 157-et kettes számrendszerbe:

157 1
78 0
39 1
19 1
9 1
4 0
2 0
1 1
0  

 

A dolog egyszerű. Osztunk kettővel, majd a maradékot leírjuk a jobboldali cellába, az eredményt pedig alá, ezt egészen addig ismételjük, amíg a számunk nulla nem lesz. Végül a kettes számrendszerbeli alakot alulról felfelé olvashatjuk el, így 157=10011101. Az eredményt alulról felfelé kell olvasni.

Visszaváltás tízes számrendszerbe

Végül is ugyanaz csak visszafelé:

1 0
0 2
0 4
1 8
0 18
1 36
1 74
0 150
   

A számot felülről lefelé leírjuk. Nulláról indulunk. Először hozzáadjuk a cella mellett lévő számot, majd szorzunk kettővel és azt írjuk le a lentebb lévő cellába, addig haladunk, amíg van szám. Tehát az 10010110=150.

Törtszámok átváltása kettes számrendszerbe

A törtszám egészrészét a fenti módon számoljuk ki, a törtrészt máshogyan.

Tegyük fel, hogy a törtrészünk 0.36:

0.36 0
0.72 1
0.44 0
0.88 1
0.76 1
0.52 1
0.04 0
0.08 0
0.16 0
0.32 0
0.64 1
0.28 0
0.56 1
0.02 0
0.04 0
0.08 0
0.16 0
0.32 0
... ...

Azt kell ilyenkor csinálni, hogy a törtrészt szorozni kell kettővel, majd az egészrészt leírni jobbra, a törtrészt alá. Nagyon gyakran jön ki végtelen szakaszos kettedestört. A törtrészünk: 0.36=0.010111000010100000... Felülről lefelé kell olvasni az eredményt.

Kettes számrendszerbeli törtszámok visszaírása tízesbe

Az egészrészt a szokott módon alakítjuk vissza. A törtrész kicsit másképp.

Legyen a törtrészünk 0.010111

1 0
1 0.5
1 0.75
0 0.875
1 0.4375
0 0.71875
  0.359375

A törtet jobbról balra kell leírni. Nullával kezdünk. A számhoz hozzá kell adni a tőle balra lévő számot, majd osztani kettővel és azt leírni. Az utolsó osztás eredménye lesz a törtrész.

Hogyan ad össze a számítógép?

Összeadó táblát használ:

+ 0 1
0 0 1
1 1 10

Ha a két szám egyforma, akkor 0, különben 1 az eredmény, ha mind a kettő 1, akkor van egy maradék is.

A gyakorlatban ez így néz ki:

 01011101 => 93
+01101010 => 106
 11000111 => 199

A maradék átvitele csak annyit tesz, hogy azt még hozzá kell adni a következő számhoz, úgy mint a sima kézi összeadásnál.

Hogyan tárolja a számítógép a negatív számokat?

Ügyesen. Tudnunk kell, hogy a számítógép mindig bájtokkal dolgozik. Az egész számok tárolására mindig 1,2 vagy 4 bájtot használ. Ezen belül is van előjeles és előjelnélküli egész szám. Az előjel nélküli egész szám nem szorul sok magyarázatra, hisz ezzel számoltunk az előbb. Az előjeles egész számok már más tészta.

A kérdés az, hogy hogyan lehet eltárolni azt a mínusz jelet. A számítógép úgy tárolja el a negatív számokat, hogy az első bitet kinevezi előjelbitnek, ha ez 0, akkor a szám pozitív, ha 1, akkor a negatív. A pozitív számokat ugyanúgy tárolja, ahogy megszoktuk. A negatív számokat meg úgy, hogy a pozitív számnak veszi az ellentettjét, ezt úgy csinálja, hogy minden egyes bitet átfordít, majd a kapott számhoz hozzáad egyet.

Példa:

Eredeti:     00000110 => 6
Átfordított: 11111001
Negatív:     11111010 => -6
(jelenthetne 250-et is!)

Az így átalakított szám lehetne akár pozitív is, ez csupán attól függ, hogy miként használjuk, negatívként vagy pozitívként.

Hogyan von ki a számítógép?

Veszi a második tag ellentettjét, és azt adja hozzá az elsőhöz. Így von ki. Az eredményt előjelesként kezeli.

 01100100 10100101 =>  25765
-00100101 01000100 => - 9540
 
 01100100 10100101 =>    25765
+11011010 10111100 => +(- 9540)
 00111111 01100001 =>    16225

Kivonásoknál a baloldali maradék mindig leesik, "túlcsordul". A kapott eredmény pedig mindig jó lesz, hacsaknem csordul alul, mert van alsó és felsőhatár.

Hogyan szoroz?

Úgy, ahogy mi papíron. Csak neki az egyszeregyet és az egyszernullát kell mindig kiszámolnia.

Lássunk egy gyors példát:

        00100100*01001001 => 36*73
        00100100
     00100100
  00100100       
  00101001000100          => 2628

Csupán a szorzandót kell eltolva egymás alá leírnia attól függően, hogy hol van az 1-es számjegy a szorzóban.

Hogyan csinálja ezt a negatív számokkal?

A gyakorlatban úgy, hogy először kiszámolják az előjelbitjét a végeredménynek. Ha a tényezők előjelbitjei megegyeznek 0 lesz, különben 1. Ezután a negatív számoknak veszik az ellentettjét, majd összeszorozzák a számokat. Ha az eredmény előjelére 1 jött ki a számolás elején, akkor az eredménynek veszik az ellentettjét, és azt a számot előjelesként kezelik.

10100100*00010001 (-92*17)

Előjelbit 1 lesz

Negatívok ellentettjének vétele: 01011100*00010001 (92*17)

Szorzás:

        01011100*00010001 (92*17)
        01011100
    01011100     
    011000011100 (1564)

Az eredmény:00000110 00011100 (2 bájt!)

Az előjelbit 1 volt, eredmény ellentettje: 11111001 11100100 (-1564)

Hogyan oszt?

A kettes számrendszerbeli osztás elég macerás. Ez az egyike a legösszetettebb műveleteknek. Nem tudom pontosan, hogy hogyan csinálja, csak ötletem van.

Az egyik ötlet:

- Veszi az első számjegyet.

- Megnézi, hogy nagyobb-e, mint az osztó.

- Ha nagyobb, akkor leírja, hogy 1 a számból levonja az osztót, különben leírja, hogy 0.

- Hozzáírja a következő számjegyet.

- És ez kezdődik elölről, amíg az összes számjegyet végig nem nézte.

Nyilván egészosztásról van szó, tehát törtrész nincs.

Lássunk egy példát:

01001101/00001011=              (77/11)
0<1011, 0-át írunk.
01<1011, 0-át írunk.
010<1011, 0-át írunk.
0100<1011, 0-át írunk.
01001<1011, 0-át írunk.
010011>1011, 1-et írunk, levonjuk az osztót, marad 001000
0010000>1011, 1-et írunk, levonjuk az osztót, marad 0000101
00001011>1011, 1-et írunk, levonjuk az osztót, marad 00000000
Összeolvasva: 00000111 (=7), maradék 00000000 (=0).

Remélem, hogy érthető volt. A processzor rengeteg eltolást, összehasonlítást és kivonást végez el, ezért az osztás elég lassú művelet, rengeteg órajelet emészt fel.

Negatív számoknál ugyanaz a helyzet, mint a szorzásnál, pozitívat csinálunk belőle, majd visszaváltjuk negatívba, ha kell.

Természetesen a számítógép figyeli az osztót is: nullával nem enged osztani.

Hogyan tárolja a számítógép a törtszámokat?

Két problémát is meg kell oldanunk:

- Negatív, pozitív törtszámok

- Tizedespont tárolása

A legkézenfekvőbb megoldás a normálalak lenne: egy egészrész, utána közvetlenül a tizedesjel és a törtrész, és ezt szorozzuk 2k-val, azért kettes az alap, mert kettes számrendszerben vagyunk és itt 2 hatványozása fogja a tizedesjelet jobbra ill. balra tolni.

Legyen a számunk a következő: 10100.01100. Ez normálalakban: 1.010001100*10100 lesz. Míg ez: 0.000010010100=1.0010100*10-101.

Láthatjuk, hogy normálalakban a tizedesjel mindig az első számjegy után áll. Így tároláskor nem kell foglalkozni vele, mindig úgy kell kezelni, mintha ott lenne, és kész. Továbbá vegyük észre azt is, hogy a normálalakú bináris szám mindig 1-gyel kezdődik így tároláskor azzal sem kell foglalkozni, hanem ezt a bitet lehet előjelbitként használni: 0 esetén pozitív, 1 esetén negatív a számunk.

A karakterisztikát érdekes módon tárolják, nem úgy, mint ahogy fentebb az előjeles számoknál néztük, hanem egész máshogy. A számhoz egyszerűen hozzáadnak 128-at (kétbájtos karakterisztika esetén 32768-at), és úgy tárolják el. Ezt azért teszik, mert így könnyebb vele számolni, ugyanis a karakterisztikán közvetlenül sosem végzünk műveletet, és könnyebben ellenőrizhetjük az alul ill. túlcsordulást. Ilyenkor lényegében fordítva működik az előjelbit: a nulla a negatív.

A gyakorlatban 4,6,8 és 10 bájtos valós számokat használnak.

A szaknyelvben a normálalak baloldali tényezőjét mantisszának, míg a kettes kitevőjét karakterisztikának hívják. Az így tárolt számokat pedig valósnak vagy lebegőpontosnak nevezik.

Nagyon nagy tartományban tudunk számokat tárolni, de nem mindegyiket, csak pár milliárdot az összes közül, minél nagyobb a karakterisztika, annál pontatlanabb a szám.

Nézzünk néhány példát a tárolásra, legyen a mantissza tárolására 3B, míg a karakterisztikára 1B:

10001.001010
Normálalakja: 1.0001001010*10100
A szám pozitív, a mantissza nullával kezdődik, a karakterisztikához 128 hozzáadása:
A szám tehát: 00001001 01000000 00000000 10000100 memóriában
             |        mantissza         |karakt.

-1010
Norm.: -1.010*1011
A szám: 10100000 00000000 00000000 10000011

0.001100001001011010001001111001011101
Norm.: 1.100001001011010001001111001011101*10-11
A szám: 01100001 00101101 00010011 01111101

Ha nem fér el a szám a három bájton, akkor a maradékot egyszerűen levágja a számról.

Hogyan adja össze, vonja ki a törtszámokat a gép?

A tárolást már ismerjük, de az alapműveleteket még nem igazán. A lebegőpontos műveletek elég sok órajelet elhasználnak a procidőből.

Ahhoz, hogy két normálalakbeli számot össze tudjunk adni, ahhoz a karakterisztikájukat egyenlővé kell tenni. Célszerű a kisebb karakterisztikájút átalakítani nagyobbá úgy, hogy egyesével növeljük a karakterisztikát, miközben minden lépésben jobbra toljuk a mantisszát egy bittel. Ha ezzel készen vagyunk, a mantisszákat összeadjuk. Ha esetleg egy maradék túlcsordul, akkor az eredményt egy bittel jobbra toljuk és növeljük a karakterisztikát, különben nem csinálunk semmit. Így kapjuk meg a végeredményt.

Természetesen az előjelbiteket is figyelni kell, ha a második tag negatív akkor kivonást végzünk el. Ha az első tag negatív, akkor is, csak akkor a végeredménynek az ellentettjét kell venni. Ha mindkettő negatív, az összegüket, és a végeredmény ellentettjét kell venni.

x+y kiszámolása, ha a=|x| és b=|y|
(x>0 és y>0) a+b    = a+b       [eredmény pozitív]
(x>0 és y<0) a+(-b) = a-b
(x<0 és y>0) -a+b   = -(a-b)
(x<0 és y<0) -a+(-b)= -(a+b)    [eredmény negatív]

Az összeadást előjelbitek nélkül kell elvégezni, mert az összeadás nem ismer mínuszt.

Az ellentettképzés könnyű a lebegőpontos számoknál: csak át kell fordítani az előjelbitet.

Kivonás esetén meg lehet, hogy nullával fog kezdődni a normálalakú szám ilyenkor a mantisszát balra kell tolni és a karakterisztikát csökkenteni eggyel.

Lássunk egy-két példát is rá:

 00100010 00111010 11101101  10001001  (+)
+01100100 01101100 11001001  10010001  (+)

Átalakítás:

 10100010 00111010 11101101  10001001
+11100100 01101100 11001001  10010001

Karakterisztikaállítás:

 00000000 10100010 00111010  10010001 (8-cal növelve)
+11100100 01101100 11001001  10010001
 11100101 00001111 00000011  10010001  (Ennyi lesz az eredmény)

Előjelbit a szám biztos pozitív, tehát letárolva: 01100101 00001111 00000011  10010001 lesz.

 

-a+b=-(a-b)

 10001001 00010100 10100010  10001001  (-)
+01001111 10001010 10101010  10001010  (+)

Átalakítás:

 10001001 00010100 10100010  10001001 
-11001111 10001010 10101010  10001010 

Karakterisztikaállítás:

 01000100 10001010 01010001  10001010 
-11001111 10001010 10101010  10001010 
(Kivonó nagyobb a kivonandónál, a részeredmény negatív lesz!)

Kettes komplemens képzése a kivonáshoz:

 01000100 10001010 01010001  10001010 
+00110000 01110101 01010110  10001010
 01110100 11111111 10100111  10001010

Balra kell tolni, mert nullával kezdődik:
11101001 11111111 01001110  10001001

Ez negatív szám, az előjelbit 1 marad: 11101001 11111111 01001110  10001001

Kivonandó negatív volt, ennek ellentettjét kell képezni a részeredménynek:
01110100 11111111 10100111  10001010 lesz az eredmény, így lesz letárolva.

Ez volt az összeadás, a kivonás is hasonló, csak a képleteket írom fel, hogy mit kell tenni előjeles számok esetén:

x-y kiszámolása, ha a=|x| és b=|y|
(x>0 és y>0) a-b    = a-b      
(x>0 és y<0) a-(-b) = a+b       [eredmény pozitív]
(x<0 és y>0) -a-b   = -(a+b)
(x<0 és y<0) -a-(-b)= -(a-b)    [eredmény negatív]

Hogyan szorozza a törtszámokat?

Ez viszonylag könnyebben érthető, mint a kettes számrendszerbeli összeadás, kivonás.

A normálalak lényegében egy szorzat, ezeket könnyű összeszorozni, mert a szorzás kommutatív művelet.

M1*2K1*M2*2K2=M1*M2*2K1+K2

A dolog egyszerű, a karakterisztikákat össze kell adni, majd a mantisszákat össze kell szorozni. A mantisszák szorzata valószínűleg nagyobb lesz, mint 1, ezért a végén a tizedesjelet el kell tolni, ezt a karakterisztikák növelésével lehet elérni. Ez előbbit akkor kell, amikor a szorzat több számjegyből áll, mint a két mantisszáé együttvéve, a különbséget kell hozzáadni a az eredmény karakterisztikájához..

A szorzás előtt az előjelbiteket át kell írni egyre, és a végén visszaírni őket, ha kell.

Példa:

01100110 00010101 01010101  10010001*10010101 01101100 11001000 10010100

Előjelbitek egyre állítása után a szorzás:

                           111001100001010101010101*100101010110110011001000
                           100101010110110011001000
                         100101010110110011001000
                       100101010110110011001000
                     100101010110110011001000
                   100101010110110011001000
                 100101010110110011001000
               100101010110110011001000
          100101010110110011001000
         100101010110110011001000
      100101010110110011001000
     100101010110110011001000
    100101010110110011001000                         
   100001100100110000101111001110011000011001101000

A számunk karakterisztikája:

 10010001
+10010100
 10100101
(A karakterisztika eltolt nullpontú, ezért mindig át kell fordítani az első számjegyet!)

A mantisszák összesen 48bit hosszúak. Az eredmény 49 bites, tehát eggyel növelni kell a karakterisztikát így az: 10100110 lesz.

A mantissza pedig: 10000110 01001100 00101111.

Az előjelbit beállítása után: 10000110 01001100 00101111 marad.

Tárolva: 10000110 01001100 00101111  10100110 az eredmény.

Hogyan osztja a törtszámokat?

Hasonlóan a szorzáshoz, csak itt kivonja a karakterisztikákat egymásból, és a mantisszát osztja el:

M1*2K1    M1
       =   *2K1-K2
M2*2K2    M2

Itt a számolás utáni eltolásnál a karakterisztikát annyival kell csökkenteni, amennyi az eredmény eleji nullák száma. Az osztást pedig az első 24 jegyig, vagy amekkora a mantissza hossza, végezzük.

A mantisszát úgy osztjuk el, ahogy fent az egész számokat. Ennyi.

Ez a legszámolásigényesebb művelet, mert rengeteg kivonás és ismétlés van benne, és egyben a leglassabb is.

 

ENNYIT A SZÁMOLÁSOKRÓL!

Utoljára frissítve:2007.03.18. 14:06:26