het binaire stelsel gebruiken met een vast aantal bits;

binaire getallen aftrekken en delen.

het begrip decimaal getal en rekenen met decimale getallen;

het begrip binair getal en decimale getallen omzetten naar binaire getallen en omgekeerd;

binaire getallen optellen en vermenigvuldigen.

Je kunt binaire getallen optellen en vermenigvuldigen (dat is herhaald optellen).
Maar kun je ze ook van elkaar aftrekken en op elkaar delen?
Ga er van uit, dat getallen die alleen uit nullen en énen bestaan, binair zijn.

Bereken $1110000 - 1110$ . Controleer je antwoord door decimaal rekenen.

Zet ze gewoon onder elkaar, denk om het principe van lenen ( $1000 - 111 = 0001$ ).

$1110000 - 1110 = 1100010$ .

Controle: $112_(10) - 14_(10) = 98_(10)$ .

Welk probleem krijg je bij $1110 - 1110000$ ?

Hier komt een negatief getal uit en er is geen binair minteken.

Bereken $1110000 // 1110$ . Controleer je antwoord door decimaal rekenen.

Deel op dezelfde manier als in het decimale stelsel, met een staartdeling.

$1110000 // 1110 = 1000$ .

Controle: $112_(10) // 14_(10) = 8_(10)$ .

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?

$2^8 = 256$ .

Waarom zullen er meestal systemen worden gebruikt met meer bits?

$256$ getallen is bij lange na niet genoeg.

Geef de binaire versie van $150_(10)$ en $text(-)150_(10)$ .

$150_(10) = 10010110_2$ en $text(-)150 = 01101010_2$ .

Controleer dat ook binair geldt dat $150_(10) + text(-)150_(10) = 0_(10)$ .

$10010110_2 + 01101010_2 = (1)00000000_2$ .

Bereken binair: $186_(10) - 150_(10)$ .

$186_(10) - 150_(10) = 10111010_2 + 01101010_2 = (1)00100100_2$ .

Bereken binair: $150_(10) - 186_(10)$ .

$150_(10) - 186_(10) = 10010110_2 + 01000110_2 = (0)11011100_2$ .

Bereken in een $8$ -bits binair systeem:

$1010 - 111$ .

$00001010 + 11111001 = (1)00000011$ (decimaal: $10 - 7 = 3$ ).

$111 - 1010$ .

$00000111 + 11110110 = (0)11111101$ (decimaal: $7 - 10 = text(-)3$ ).

$11011001 - 00010101$ .

$11011001 + 11101011 = (1)11000100$ (decimaal: $217 - 21 = 196$ ).

$00010101 – 11011001$ .

$00010101 + 00100111 = (0)00111100$ (decimaal: $217 - 21 = text(-)196$ ).

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.

Je haalt eerst $100$ keer $1101$ van $1000001$ af:
$01000001 - 00110100 = 01000001 + 11001100 = (1)00001101$ .

Vervolgens haal je $1$ keer $1101$ van $00001101$ af: $00001101 - 00001101 = 00000000$ .

Dus kun je $100 + 1 = 101$ keer $1101$ van $1000001$ afhalen.
Ofwel: $1000001 // 1101 = 101$ .

Controle: $65_(10) // 13_(10) = 5_(10)$ .

Hoe zou je $1101 // 1000001$ berekenen?

Ofwel zo laten, het antwoord wordt dan als breuk weergegeven, ofwel een binaire komma invoeren. Zie Toepassen.

Het rekenen met binaire getallen gaat op vergelijkbare wijze als in het decimale stelsel. Voor optellen en vermenigvuldigen gebruik je:

$0 + 0 = 0$ , $0 + 1 = 1$ , $1 + 0 = 1$ en $1 + 1 = 10$ ;

$0 * 0 = 0$ , $0 * 1 = 0$ , $1 * 0 = 1$ en $1 * 1 = 1$ .

Bij aftrekken en delen werk je binnen een systeem met een vast aantal bits en het binaire complement van een getal. Dat is het getal de je krijgt door de nullen in énen en omgekeerd de énen in nullen te verwisselen en daar $1$ bij op te tellen.

Omdat $a-b = a+text(-)b$ tel je $a$ en het complement van $b$ op.

Bij de deling $a//b$ trek je $b$ zo vaak mogelijk af van $a$ . Al die aftrekkingen zet je om in optellen van het complement van $b$ .

In de voorbeelden zie je hoe dit in zijn werk gaat.

Reken $417_(10)$ en $38_(10)$ om naar hun binaire vorm en bereken $417_(10) - 38_(10)$ en $38_(10) - 417_(10)$ .
Ga uit van een $16$ -bits binair stelsel.

Je moet beide getallen schrijven als optelling van machten van $2$ .
Dat bereik je door steeds door $2$ te delen en de rest op te schrijven:

$417_(10) = 0000000110100001$

$38_(10) = 0000000000100110$

Het binaire complement van $38$ is:

$1111111111011001 + 1 = 1111111111011010$

En dus wordt $417_(10) - 38_(10)$ :

$\ \ \ \ \ 0000000110100001$
$ul(\ \ \ \ \ 1111111111011010 +)$
$(1)0000000101111011$

Ga na dat dit in decimale notatie inderdaad $379_(10)$ is.

En zo gaat $38 - 417$ :

$\ \ \ \ \ 0000000000100110$
$ul(\ \ \ \ \ 1111111001011111 +)$
$(0)1111111010000101$

En dit is het binaire complement van $0000000101111011 = 379_(10)$ .

En dus: $(0)1111111010000101 = text(-)379_(10)$ .

Je ziet dat de voorste (eigenlijk de $17$ e bit die niet wordt gebruikt) wel moet worden bijgehouden om te bepalen of het getal positief (als het een $1$ betreft) of negatief (als het een $0$ betreft) is.

Zet de getallen om naar een $16$ -bits binair stelsel en bereken.

$336_(10) - 123_(10)$

$0000000101010000 - 0000000001111101 =$
$0000000101010000 + 1111111110000011 = 0000000011010101$

$123_(10) - 336_(10)$

$0000000001111101 - 0000000101010000 =$
$0000000001111101 + 1111111010110000 = (1)0000000011010101$

$35_(10) - (46_(10) + 19_(10))$

$46_(10) + 19_(10) = 0000000001000011$
Dus: $0000000000100011 + 1111111010110000 = 1111111111100000$ .

Bereken (indien mogelijk) in een $8$ -bits binair stelsel:

$00100100 + 01111011$

$10011111$

$00100100 - 01111011$

$(0)10101001$

$01111011 - 00100100$

$(1)10101001$

$00100100 * 01111011$

Dit past niet in een $8$ -bits systeem.

Reken $227_(10)$ en $38_(10)$ om naar een binaire vorm en bereken $227_(10) // 38_(10)$ .
Ga uit van een $8$ -bits binair stelsel.

Ga na:

$227_(10) = 11100011$

$38_(10) = 00100110$

Nu is een deling niets anders dan zoveel mogelijk keer (in dit geval) $38_(10)$ van de $227_(10)$ aftrekken en kijken wat je nog over houdt. Denk daarbij om het feit dat het binair stelsel werkt met machten van $2_(10) = 10_2$ .

$00100110$ kan (om te beginnen) $100$ keer van $11100011$ af.
Omdat $100 * 00100110 = 10011000$ , houd je over:
$11100011 - 10011000 = 11100011 + 01101000 = (1)01001011$ .

Vervolgens kan $00100110$ nog $1$ keer ( $10$ keer gaat niet) van $01001011$ af:
$01001011 - 00100110 = 01001011 + 11011010 = (1)00100101$ .

Nu kun je een apparaat opdracht geven (programmeren heet dat) om de uitkomst ( $100 + 1 +$ de rest) op te schrijven als $11110111 // 00100110 = 00000101$ rest $00100101$ .

Je kunt ook op dezelfde manier door blijven delen, alleen moet er dan een scheidingsteken komen, net zoals de decimale komma (vaak decimale punt) in het decimale stelsel.

Decimale controle: $227_(10) // 38_(10) = 5_(10)$ met rest $37_(10)$ .
Ga na, dat dit met het binaire antwoord overeen komt.

Voer zelf de berekeningen in het Voorbeeld uit.

Doen, vergelijk je resultaten met het voorbeeld.

Reken $186_(10)$ en $13_(10)$ om naar een binaire vorm en bereken $186_(10) // 13_(10)$ .
Ga uit van een $8$ -bits binair stelsel en geef je antwoord op de manier van het Voorbeeld.

$10111010 // 00001101 = 00001110$ rest $00000100$ .
Controle: $186_(10) // 13_(10) = 14_(10)$ rest $4$ .

Bereken $1010111 // 00001101$ .
Controleer je antwoord door rekenen in het decimale stelsel.

$01010111 // 00001101 = 00000110$ rest $00001001$ .
Controle: $87_(10) // 13_(10) = 6_(10)$ rest $9_(10)$ .

Gegeven zijn de getallen $a = 11001101$ en $b = 101001$ in een $8$ -bits binar stelsel.

Bereken $a - b$ . Controleer je antwoord door de getallen om te rekenen naar decimale getallen.

$a - b = 11001101 - 00101001 = 11001101 + 11010111 = (1)10100100$ .
En $205_(10) - 41_(10) = 164_(10) = 10100100_2$ .

Bereken $b - a$ . Controleer je antwoord door de getallen om te rekenen naar decimale getallen.

$b - a = 00101001 - 11001101 = 00101001 + 00110011 = (0)10100100$ .
En $41_(10) - 205_(10) = text(-)164_(10) = (0)10100100_2$ .

Bereken $a // b$ .

$a//b = 100 + 1 = 101$ .
En $205_(10) // 41_(10) = 5_(10) = 101_2$ .

Je werkt in een $16$ -bits binair stelsel.

Hoe groot is het grootste getal dat je daarin kunt maken?
Geef dit getal in binaire en in decimale vorm.

$1111111111111111 = 2^(15) + 2^(14) + ... + 2^2 + 2^1 + 2^0 = 65535_(10)$ .

Hoe ziet het binaire complement van dit grootste getal er uit?

$0000000000000001$

Laat met een binaire berekening zien dat de optelling van de getallen bij a en b inderdaad op 0 uitkomt.

$1111111111111111 + 0000000000000001 = (1)0000000000000000$ .

Bereken binair in een $8$ -bits systeem:

$(156_(10))/(6_(10) + 7_(10))$

$6_(10) + 7_(10) = 110 + 111 = 1101 (= 13_(10))$

$(156_(10))/(1101_2) = (10011100)/(1101) = 1100 (=12_(10))$

$15_(10) * (11/3)_(10)$

$15_(10) * (11/3)_(10) = 15_(10) * (11_(10))/(3_(10)) = (15_(10))/(3_(10))*11_(10)$

$(15_(10))/(3_(10)) = (1111)/(11) = 101$

$101_2 * 11_(10) = 101 * 1011 = 110111 (= 55_(10))$

Delingen komen vaak niet uit. Bereken de volgende delingen binair in een $8$ -bits systeem en geef het antwoord met rest. Controleer je antwoord met het decimale stelsel.

$11010 // 101$

$00011010 // 00000101 = 101$ met rest $1$ .
Controle: $26_(10) // 5_(10) = 5_(10)$ met rest $1_(10)$ .

$11011010 // 111$

$11011010 // 00000111 = 11111$ met rest $1$ .
Controle: $218_(10) // 7_(10) = 31_(10)$ met rest $1_(10)$ .

Er bestaan ook in het binaire stelsel getallen met cijfers achter de komma.
Eigenlijk werkt dat net als met gewone gehele getallen, maar nu zijn de exponenten van de machten van $2$ negatief.

Bijvoorbeeld: $0,1101_2 = 0*2^0 + 1*2^(text(-)1) + 1*2^(text(-)2) + 0*2^(text(-)3) + 1*2^(text(-)4)$ .
En dit wordt: $0,1101_2 = 0_(10) + 0,5_(10) + 0,25_(10) + 0_(10) + 0,0625_(10) = 0,8125_(10)$ .

Het omrekenen van een decimaal getal met een komma erin naar een binair getal gaat voor de uitdrukking achter de komma nu niet door delen door $2$ , maar vermenigvuldigen met $2$ . In de figuur zie je hoe dat gaat. Als het goed is heb je dit al bij Binaire getallen een paar keer gedaan.

Nu ga je rekenen met binaire getallen met en zonder komma erin en in een $8$ -bits systeem.

Je wilt $11,1101 - 0,101$ berekenen.

Hoe geef je beide getallen in het $8$ -bits systeem weer?

Bijvoorbeeld als $11,110100$ en $00,101000$ .

Of als $0011,1101$ en $0000,1010$ .

Voer nu de berekening uit. Controleer je antwoord decimaal.

$0011,1101 - 0000,1010 = 0011,1101 + 1111,0110 = (1)0011,0011$

Controle: $11,1101_2 - 0,101_2 = 3,8125_(10) - 0,625_(10) = 3,1875_(10) = 0011,0011_2$ .

Nu wil je $10,1101 // 0,101$ berekenen.

Voer deze berekening uit.

$10,1101 // 0,101 = 00101101 // 00001010 = 100,1$

Controle: $10,1101_2 // 0,101_2 = 2,8125_(10) // 0,625_(10) = 4,5_(10) = 100,1_2$ .

Je hebt al eerder gezien dat niet alle decimale breuken binair zijn weer te geven als je met een vast aantal bits werkt.

Laat zien, dat $0,6_(10) = 0,100110011001..._(2)$ .

Doe dit op dezelfde manier als in het Toepassen, of voer de deling $6_(10)//10_(10) = 110_2 // 1010_2$ uit.

Waarom kun je $0,6_(10)$ niet als een eindig binair kommagetal weergeven en $0,75_(10)$ wel?

$0,75_(10) = 0,5_(10) + 0,25_(10) = 2^(text(-)1) + 2^(text(-)2) = 0,11_2$ .

Is $0,1_(10)$ in een $24$ -bits binair systeem weer te geven?

Nee: $0,1_(10) = 0,00011001100110011..._2$ .

Gegeven zijn de getallen $a = 110101$ , $b = 11101$ en $c = 1010111$ in een $8$ -bits binair stelsel.

Bereken $a - b$ en controleer je antwoord in het decimale stelsel.

$a - b = 00110101 - 00011101 = (1)00011000$

$a = 110101_2 = 53_(10)$ en $b = 11101_2 = 29$ .
$a-b = 53_(10) - 29_(10) = 24_(10) = 00011000_2$ .

Bereken $c // b$ .

$c // b = 11$

$c = 1010111_2 = 87_(10)$ en $b = 11101_2 = 29$ .
$c//b = 87_(10) // 29_(10) = 3_(10) = 11_2$ .

Gegeven de decimale getallen $153$ en $67$ .
Je gaat ze van elkaar aftrekken en op elkaar delen in een $8$ -bits binair stelsel.

Bereken $153 - 67$ . Controleer je antwoord in het decimale stelsel.

$10011001 - 01000011 = 10011001 + 10111101 = (1)01010110$ .
Ga na dat $01010110_2 = 153_(10) - 67_(10) = 86_(10)$ .

Bereken $153 // 67$ . Geef het antwoord met rest. Controleer je antwoord in het decimale stelsel.

$10011001 // 01000011 = 10$ met rest $10011$ .
Ga na dat $10_2 = 153_(10) // 67_(10) = 2_(10)$ met rest $19_(10)$ .