Bij het aftrekken van twee binaire getallen loop je aan tegen het probleem dat er geen negatiefteken is, dus
`0 - 1 = ???`
Hoe maak je het negatieve getal bij bijvoorbeeld
`186`
. In het tientallig stelsel heb je het dan over
`text(-)186`
, want
`186 + text(-)186 = 0`
. Maar hoe maak je
`text(-)186`
in het binaire stelsel?
Om dit probleem op te lossen wordt het aantal tekens, in computertaal het aantal bits (een bit is een "binary digit" ), beperkt tot `8` , of `16` , of `32` , of `64` . Nadeel daarvan is dat je hiermee het aantal getallen dat je kunt maken, beperkt.
Stel je een
`8`
-bits beperking voor.
Het getal
`186_(10) = 10111010_2`
is zo’n
`8`
-bits getal.
Het bijbehorende negatieve getal is
`text(-)186_(10)`
en moet opgeteld bij
`186_(10)`
weer
`0`
opleveren.
Nu kun je in een
`8`
-bits systeem zeggen
`0 = 100000000`
, want die voorste
`1`
is de negende bit en die wordt niet
"gezien"
.
Verwissel in
`10111010`
de nullen in énen en omgekeerd en tel er
`1`
bij op, dan krijg je het getal
`01000101 + 1 = 01000110`
.
Dit heet het binaire complement van het (binaire) getal
`10111010`
.
En opgeteld zijn ze samen
`10111010 + 01000110 = (1)00000000 = 0`
.
De overdracht naar de negende bit laat je weg omdat je hebt afgesproken in
`8`
-bits te werken, vandaar dat die tussen haakjes staat. Een getal en zijn binaire complement zijn samen
`0`
. Het binaire complement heeft dezelfde rol als het negatieve getal in het decimale stelsel.
Als je nu
`186_(10) - 150_(10)`
binair wilt berekenen, doe je
`186_(10) + text(-)150_(10)`
.
En
`150_(10) - 186_(10) = 150_(10) + text(-)186_(10)`
.
En delen is herhaald aftrekken...
Je werkt in een `8` -bits systeem.
Hoeveel gehele getallen groter of gelijk `0` kun je dan maken?
Waarom zullen er meestal systemen worden gebruikt met meer bits?
Geef de binaire versie van `150_(10)` en `text(-)150_(10)` .
Controleer dat ook binair geldt dat `150_(10) + text(-)150_(10) = 0_(10)` .
Bereken binair: `186_(10) - 150_(10)` .
Bereken binair: `150_(10) - 186_(10)` .
Bereken in een `8` -bits binair systeem:
`1010 - 111` .
`111 - 1010` .
`11011001 - 00010101` .
`00010101 – 11011001` .
Het delen van twee binaire getallen gaat net als het met de hand delen van twee decimale getallen. Werk weer in een `8` -bits systeem.
Bereken
`1000001 // 1101`
.
Controleer je antwoord door beide getallen eerst te vertalen naar decimale getallen.
Hoe zou je `1101 // 1000001` berekenen?