Képzeld el, hogy egy számot szeretnél ábrázolni a számítógépben.
Ehhez a gép bitjeit (0-kat és 1-eket) használja, és a legfontosabb kérdés az, hol legyen a tizedespont.

A fixpontos számrendszerben ez a pont fix helyen van – azaz előre megmondjuk, hány bit tartozik az egész részhez, és hány a törtrészhez.
Innen jön a neve is: fixed-point, vagyis rögzített tizedespontú.

Ez különbözik a lebegőpontos rendszertől, ahol a pont helye változhat (azaz lebeg), és ezért sokkal nagyobb számokat is tudunk ábrázolni – de bonyolultabban.

Műveletek

A fixpontos számrendszerekkel ugyanúgy végezhetünk összeadást és kivonást, mint a sima egész számokkal – hiszen a bitműveletek megegyeznek.
De ha szorzást vagy osztást végzünk, figyelni kell a tizedespont helyére, mert az elmozdulhat.
Ez azért fontos, mert a végeredményben más lehet az egész–tört arány, mint amit eredetileg kijelöltünk.

Ez a képlet az előjeles, bináris fixpontos szám értékét adja meg. Nézzük meg részletesen, mit jelent:
bN−1 -> az utolsó (legmagasabb helyiértékű bit, amit előjelbitnek nevezünk. Ha ez a szám 0, akkor a szám pozitív, ha 1, akkor a szám negatív.

N -> teljes bithossz, azaz hány bitből áll a szám, például 8 vagy 16

p -> a tizedespont helye, azaz hány bit tartozik a törtrészhez

2^i-p -> ez mutatja meg, hogy az adott bit milyen helyiértéket képvisel. 

A képlet tehát nem más, mint a szám bináris helyiértékeinek összege – figyelembe véve az előjelet és a tizedespont helyét. 

Mit jelent az, hogy „fixpontos”?

A számítógép minden számot bitek sorozataként tárol. Ha ezek egész számok, akkor egyszerű: minden bit egy-egy hatvány a kettes számrendszerben.
De mi van, ha törteket is szeretnénk tárolni? Valahol el kell helyezni a tizedespontot (vagy binárisban: radix point).

A fixpontos számrendszerben ez a pont előre meghatározott helyen van.
Mondjuk például: „a 16 bitből 8 az egész rész, 8 a törtrész”. Innentől kezdve nincs vita: minden számot ebben a formában kell értelmezni. Így néz ki például egy 16 bites fixpontos formátum (p = 8):

Miért használják mégis?

Mert gyors.
A számítógép nem kell, hogy újra és újra kiszámolja, hová kell „tennie” a tizedespontot, mint a lebegőpontos műveleteknél.
A fixpontos forma sokkal egyszerűbb logikát igényel – és ez az egyszerűség értékes az olyan eszközöknél, ahol kevés az erőforrás: mikrokontrollerek, DSP-k, jelfeldolgozás, beágyazott rendszerek.

Ráadásul kis tartományban sokkal stabilabb és pontosabb, mint a lebegőpontos számok.
Ha például hangot vagy képet dolgozol fel, nem akarsz lebegő tizedespontokat, csak egy kis, precíz fix skálát.

A lépésköz – a rendszer „felbontása”

A fixpontos számrendszer egyik kulcsfogalma a Δr, azaz a differencia vagy felbontás.
Ez azt mutatja, mennyi a különbség két egymást követő szám között.

$$\Delta r = 2^{-p}$$

Ha p = 8, akkor:

$$\Delta r = 2^{-8} = \frac{1}{256} \approx 0.00390625$$

Ez azt jelenti, hogy a legkisebb „ugrás” a számok között kb. 0,0039.
Olyan ez, mintha a mérleged nem grammokat, hanem csak 4 grammos lépésekben mérne — nem rossz, csak tudni kell, hogy mennyire „durván” mérsz.

Egy konkrét példa

Legyen egy 16 bites fixpontos rendszer, ahol:

• N = 16 bit

• p = 8 bit (törtrész)

• előjeles (2’s complement) formátumot használunk

Ez azt jelenti: 1 bit az előjelre, 7 bit az egész részre, 8 bit a törtrészre jut.

Miért nem szimmetrikus a tartomány?

Ha ránézel a számokra, rögtön feltűnik, hogy a tartomány −128 és +127.996 között van.
És felmerül a kérdés:
„Miért nem −128 és +128?”
Teljesen jogos.

A válasz az előjelbit.

A fixpontos, előjeles bináris számok kétkomplementes formában működnek.
Ez azt jelenti, hogy az első (bal szélső) bit nem számértéket, hanem előjelet jelöl:

• 0 → pozitív szám,

• 1 → negatív szám.

Ettől viszont a tartomány egy kicsit félrebillen.
A pozitív oldalon az egyik kombináció (amikor minden bit 1 lenne) „átcsúszna” a negatív tartományba, ezért onnan egy szám hiányzik.

💬 Összefoglalva:
A legnagyobb negatív szám (−128) teljes egészében lefedett,
a legnagyobb pozitív pedig egy hajszállal kisebb (+127.996).
Nem hiba – ez a kétkomplementes kódolás természetes velejárója.

A tizedespont helye – miért „fix”?

Ez az egész történet lényege.
A „pont” nem egy tényleges karakter, nem tárolódik a memóriában.
A számítógép nem jegyzi meg, hova tettük a pontot – csak tudja, hogy hol kell képzeletben lennie.

Ha például azt mondjuk:
„Ez egy 16 bites fixpontos szám, amiben 8 bit a törtrész”,
akkor a gép automatikusan úgy értelmezi, hogy a tizedespont 8 bit után van a jobbról számolva.

Ez a fixpontos rendszerek legfontosabb szabálya:
a pont nem mozdulhat, mert ez az egész ábrázolás stabilitását adja.

💬 Gyakorlati példa:
Ha ugyanazt a 16 bitet másként értelmezed (mondjuk 4 bit törtrész, 12 egész), akkor a szám teljesen más értéket adna.
Ezért fix, mert a program és a hardver közösen megegyeznek a helyéről.

Pontosság vs. tartomány – az örök csereüzlet

Minél több bitet adsz a törtrészhez, annál pontosabban tudod kifejezni a számokat —
de közben kevesebb hely marad az egész részre.

Ha kevesebb bit a törtrész, akkor nagyobb számokat tudsz ábrázolni, de kevésbé részletesen.

Ez egy kompromisszum, amit minden mérnöknek meg kell kötni.

Olyan ez, mint a fényképeknél a felbontás:
ha túl nagyra nagyítasz, elveszik a részlet;
ha túl kicsire méretezel, minden pixeles lesz.

Példa:

• p = 8 → 1/256-os pontosság, tartomány kb. −128…+127.996

• p = 4 → 1/16-os pontosság, tartomány kb. −2048…+2047.9375

💬 Vagyis:
A pontosság mindig az ár, amit a nagyobb tartományért fizetsz.

Miért nem használ mindenki lebegőpontos számokat?

Jogos kérdés.
A lebegőpontos számok sokkal „rugalmasabbak” – a tizedespont helye változhat, így hatalmas tartományt fedhetnek le.
A kérdés viszont: mindenáron kell az a rugalmasság?

A válasz legtöbbször: nem.

A fixpontos számrendszereknek két hatalmas előnyük van:

Sebesség.
Egy mikrokontroller, ami például egy robotkart irányít, nem akar lebegőpontos számokat tologatni.
Az drága művelet, sok energiát és időt igényel.
A fixpont viszont azonnal működik, mert egyszerű egész műveleteket végez.

Kiszámíthatóság.
A fixpontos műveletek mindig ugyanazt az eredményt adják, nincs „kerekítési meglepetés”, mint a lebegőpontos világban.

Itt jön képbe az előjeles 2’s komplemens rendszer,
ami már nem csak a műveletek egyszerűsítéséről szól, hanem a negatív számok értelmezéséről is.

Mi az az MSB, és miért fontos?

 A számítógép minden számot bitek sorozataként tárol.
Egy 8 bites példában például így nézhet ki egy szám: 01001110

Ebben minden bitnek van helyiértéke, ahogy a tizes számrendszerben is van egyese, tizese százas helyiértéke. A binárisban a helyiértékek a 2 hatványai:

• a legkisebb (jobboldali) bit az 2⁰,

• a következő 2¹,

• aztán 2², 2³, és így tovább.

A bal szélső bit (a legnagyobb helyiértékű) az úgynevezett
➡️ MSB – Most Significant Bit, azaz a legnagyobb helyiértékű bit.

És itt jön a lényeg:
a 2’s komplemens rendszerben ez a legelső bit jelöli az előjelet.

• Ha az MSB = 0, akkor a szám pozitív.

• Ha az MSB = 1, akkor a szám negatív.

Például: 01001110₂ = +78₁₀, 11001110₂ = -50₁₀

A különbség mindössze az első bit, mégis teljesen más a jelentése!
A gép ebből az egyetlen jelből tudja, hogy az értéket a 2’s komplemens logika szerint kell értelmeznie.

A trükk egyszerű, de zseniális:
ahol 0 volt, ott 1 lesz, ahol 1 volt, ott 0 lesz.

Ezt nevezzük bitenkénti negálásnak vagy inverziónak.
Ez azt jelenti, hogy a pozitív szám minden bitjét megfordítjuk, és ezzel megkapjuk a negatív párját.

A számítógépben csak 0 és 1 létezik. De mi történik, ha negatív számokat akarunk megjeleníteni? A gépnek ugyanis nincs külön „mínuszjel” gombja — neki minden csak 0 vagy 1.

És itt lép be az 1’s komplemens rendszer, ami az egyik legkorábbi módszer volt a negatív számok bináris ábrázolására.

Mi a lényege?

A trükk egyszerű, de zseniális: ahol 0 volt, ott 1 lesz, ahol 1 volt, ott 0 lesz.

Ezt nevezzük bitenkénti negálásnak vagy inverziónak.
Ez azt jelenti, hogy a pozitív szám minden bitjét megfordítjuk, és ezzel megkapjuk a negatív párját. Például: 001010 > 110101

A második szm az első 1’s komplemens alakja. 

Miért jó ez?

Mert a számítógépnek csak annyi dolga van, hogy minden bitet „felcseréljen”.
Nincs bonyolult kivonás vagy külön jelölés – egyetlen logikai művelettel megkapja a negatív formát.
Ezért az 1’s komplemens rendszer gyorsan és egyszerűen működik.

Ha N bit áll a rendelkezésünkre, akkor az 1S komplemens rendszer értéktartománya így néz ki

−(2^(N−1) − 1) … + (2^(N−1) − 1). Ha 8 bitünk van, akkor: -127 …. + 127

De van egy kis probléma ezzel: Az 1’s komplemens rendszer nem helyiértékes, ezért előfordul, hogy kétféleképpen is le tudjuk írni a nullát:

00000000 -> +0
11111111 -> -0
A gépnek pedig meg kéne tanulnia, hogy  kétféle nulla ugyanazt jelenti. Ezért mondjuk, hogy az 1’s komplemens ellenőrzést igényel, és emiatt később felváltotta a 2’s komplemens. 

Összefoglalva

Az 1’s komplemens rendszer a negatív számok megjelenítésének első „okos” bináris trükkje volt.
Gyors, egyszerű, de pontatlan: a kétféle nulla és a helyiérték hiánya miatt ma már csak tanulási célból használjuk.
De nélküle nem született volna meg a modern 2’s komplemens – az a rendszer, amit a géped ma is használ! ⚡

avagy hogyan gondolkodik a gép a negatív számokról

A 2’s komplemens tulajdonképpen a „felturbózott” verzió: mindössze annyit csinálunk, hogy a korábban kapott komplemenshez hozzáadunk +1-et. És ezzel elérjük, hogy a számítógép a kivonást is egyszerű összeadással végezze el – villámgyorsan és hibamentesen.

Ez az apró lépés, a +1 hozzáadása, egy teljes logikai áttörés volt: mostantól a gép nem „külön gondolkodik” a negatív számokról, hanem egyszerűen ugyanazt az áramkört használja hozzá, mint az összeadáshoz. Így a kivonás = komplemens + 1 + összeadás.

A következő példában látni fogjuk, hogyan számol a gép a 2’s komplemens segítségével, és mit jelent valójában az a kis „túlcsorduló” 1, ami látszólag eltűnik – pedig ez teszi lehetővé, hogy a bináris világban minden érték „körbeérjen”.

Az előző leckében már megtanultuk, hogyan működik a p’s komplemens a 10-es számrendszerben — ott a „+1 trükk” segített abban, hogy a kivonás egyszerűen összeadássá váljon. Most ugyanezt az elvet nézzük meg binárisan, azaz a 2-es számrendszerben.

A különbség mindössze annyi, hogy:

• a 10-es rendszerben a „p” = 10,

• a binárisban pedig „p” = 2.

Vagyis most már a 2’s komplemensről beszélünk.

Mit jelent ez a gyakorlatban?

A bináris számrendszerben minden bitet megfordítunk: 

• a 0-ból 1 lesz,

• az 1-ből pedig 0.

Ez az úgynevezett 1’s komplemens. Ha ehhez hozzáadunk +1-et, akkor megkapjuk a 2’s komplemenst – vagyis azt a formát, amivel a gép a negatív számokat is tudja kezelni és a kivonást is egyszerűen elvégzi.

Vegyünk egy 8 bites bináris számot, például:

0011 0001₂

Ez a szám pozitív, és decimálisan 49₁₀-et jelent.

🔹 1. lépés – Képezd az 1’s komplemenst

A bináris 1’s komplemens egyszerűen azt jelenti, hogy minden bitet megfordítunk:

• ahol 0 volt, ott 1 lesz,

• ahol 1 volt, ott 0 lesz.

Tehát:
Eredeti: 0011 0001
Komplemens: 1100 1110

Ez a művelet bitenkénti negálás (invertálás). 

🔹 2. lépés – Adj hozzá +1-et

A következő lépésben a gép egyet hozzáad ehhez az 1’s komplemenshez:

1100 1110
+          1
──────────
1100 1111

Ez már a 2’s komplemens, vagyis a bináris „negatív párja” az eredeti számnak.
Ha a gép ezt a formát látja, tudja, hogy a szám negatív, és a számértéket ebből fogja kiszámolni.

Miért működik ez?

A kettes komplemens tulajdonképpen azt mondja:
„Egészítsd ki a számot a következő bináris alapig, azaz 2ⁿ-ig.”

8 bit esetén ez: 2⁸ = 256

Ha az eredeti szám 49, akkor a 2’s komplemens (a „negatív párja”) 256 − 49 = 207 lesz,
vagyis a gép így reprezentálja a −49-et.

Ellenőrzés

Ha összeadod az eredeti és a kettes komplemens alakot, mindig megkapod a teljes „kört”:

 0011 0001
+ 1100 1111
──────────
1 0000 0000

Az 1 „túlcsordul”, vagyis kiesik, és a 8 bites helyen marad: 0000 0000. Ez pontosan a bináris nullát jelenti – a rendszer tehát bezárult, visszatért a nullához. 

Számoljuk ki a 43₁₀  kettes komplemensét.

1. lépés: Megnézem, hogy negatív számról van-e szó. Nem negatív, tehát átkonvertálom bináris számrendszerbe és úgy hagyom, mert a pozitív szám kettes komplemense önmaga. 

Eredmény: 43₁₀ = 00101011₂

Számoljuk ki a −123₁₀ kettes komplemensét.

1. lépés: Ez most negatív szám, tehát végig kell csinálnunk a 2’s komplemens lépéseit. Ehhez 8 bitet használunk (mert ez a leggyakoribb fix hossz).
2. lépés: Elhagyjuk az előjelet és átkonvertáljuk a szám abszolút értékét binárisra: 123₁₀ = 01111011₂
3. lépés: Minden bitet megfordítunk (1’s komplemens): 01111011 → 10000100
4. lépés: Hozzáadunk +1-et (2’s komplemens): 10000100 + 1 = 10000101

Eredmény: −123₁₀ = 10000101₂

A 2’s komplemens eljárás azért zseniális, mert így a gép nem külön kezeli a negatív számokat.
Az 10000101₂ értéke a gép számára automatikusan −123 lesz, mert az első bit (a legbaloldalibb) 1, tehát ez egy negatív szám — a rendszer pedig a 2’s komplemens szabály szerint dekódolja.

1. feladat Számoljuk ki a 67₁₀ kettes komplemensét!

2. feladat: Számoljuk ki a –58₁₀ kettes komplemensét!

3. feladat: Számoljuk ki a –103₁₀ kettes komplemensét!

A komplemens képzés nem más, mint egy trükkös módja annak, hogy egy számot „kiegészítsünk” egy másik számmal, amivel együtt egy fix, maximális értéket adnak ki.
Ez az elv működik bármilyen számrendszerben – legyen az 10-es, 8-as vagy 2-es alapú.

Általánosan fogalmazva:
ha egy számrendszer alapszáma p, akkor az úgynevezett
p – 1’s komplemens azt a számot jelenti,
amely egy adott N számjegyű számot kiegészít az összes jegyben p – 1 értékre.

Vegyük a 10-es számrendszert, ahol p = 10, és nézzük meg, mi történik 3 számjegy esetén:

A maximálisan elérhető 3 jegyű szám: 10³ − 1 = 999. Legyen a kiinduló számunk: 234. Ekkor: 999-234 = 765

Ez azt jelenti, hogy 765 az a szám, amely „kiegészíti” a 234-et az összes helyiértéken 9-re.

Ezért 765-öt a 234 kilences komplemensének nevezzük
(ugyanis a 9 = p – 1 ebben a rendszerben).

Legyen a számunk: 010₂. A komplemensét úgy kapjuk meg, hogy minden bitet megfordítunk: 010 -> 101. Ezzel a módszerrel a szám és komplemense mindig „kitölti” a rendelkezésre álló helyet egyesekkel, azaz: 010 + 101 = 111. 
És kész is, ez az 1’s komplemens rendszer lényege binárisan. 

A komplemens képzés logikáját megérteni nemcsak programozásban hasznos – hanem segít abban is, hogy jobban átlássuk, hogyan gondolkodik a gép az adatok mögött.